home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 May: Tool Chest / Developer CD Series Tool Chest (Apple Computer)(May 1999).iso / Tool Chest / Development Kits / MPW etc / MPW-GM / MPW / Examples / 32BitAExamples / Count.a next >
Encoding:
Text File  |  1998-12-03  |  19.5 KB  |  630 lines  |  [TEXT/MPS ]
  1.                 TITLE            'Count - An MPW tool using -model far'
  2. *-------------------------------------------------------------------------------------------
  3. *
  4. * NAME
  5. *        Count.a -- count lines and characters
  6. *
  7. * SYNOPSIS
  8. *        Count [-l] [-c] [file…]
  9. *
  10. * DESCRIPTION
  11. *        "Count" counts the lines and characters in its input and writes the
  12. *        counts to standard output.  If no files are specified, standard input is
  13. *        read.  If more than one file is specified, separate counts are written
  14. *        for each file, one per line, preceded by the file name.  A total is also
  15. *        written following the list of files.
  16. *
  17. * COPYRIGHT
  18. *        Copyright Apple Computer, Inc. 1985-1993
  19. *        All rights reserved.
  20. *
  21. *                 Demonstration of use of "32-bit everything" addressing.
  22. *                                 for MPW 3.2 Assembler.
  23. *
  24. *     Briefly, "32-bit everything" allows the use of the absolute long addressing mode of
  25. * 680x0 instructions in Macintosh code to refer to both code and data.  Normally,
  26. * because everything in the Macintosh is considered relocatable, this addressing mode
  27. * could not be used; the only "absolute" addresses were low memory globals (and there
  28. * have been warnings about using those!).  However, with a patch to LoadSeg to allow
  29. * for a different format of the CODE 0 segment jump table, and to allow run-time patching
  30. * of these "absolute" addresses, it is now possible to use the absolute long addressing
  31. * mode. (Note that the linker adds the patch installer/de-installer code to the user's
  32. * code, so the effect is localized).  Thus, the MPW compilers and linker allow
  33. * "relocatable" (by runtime patch) "absolute" (by 680x0 addressing mode) instructions.
  34. * You invoke the feature by using the "-model far" option on the command line for
  35. * compilers, assembler and linker.
  36. *
  37. *    In addition to the "-model far" command line option, the user must enable the feature on a
  38. * "per-instruction" basis in Asm.  This program is a modified version of the count program provided
  39. * provided in the :Aexamples:folder to demonstrate how to use the Assembler
  40. * to get the 32-bit everything references.  Unlike the compilers, the user must specify
  41. * which instructions will use this feature by explicitly using a specific absolute addressing
  42. * mode syntax ("(Mylabel).L") . Further, the label used must be "imported". 
  43. * To make life easier, there are "implicit" imports provided by the Assembler:
  44. * Within the same file, preceding data references are implicitly imported, 
  45. * as are all preceding module names. (You cannot, at this time, use a 32-bit reference
  46. * to refer to a module name within that module, however). Note that the use of 32-bit 
  47. * addressing in the Assembler is independent of the CODEREFS and DATAREFS directive
  48. * settings, and that the 32-bit displacements of the 68020+ addressing modes are not
  49. * affected; this is for backward compatibility.
  50. *
  51. *   Within this program, then, you will see absolute references to all kinds of data
  52. * references:  simple Data references, qualified field references and field references 
  53. * under a 'WITH' statement.  Since "data" is implicitly imported, no matter where it is
  54. * found, Main data and data defined in the 'DATA' section of a code module can be
  55. * successfully referenced.
  56. *
  57. *     Additionally, but more simply, there are numerous JSRs and JMPs to other code
  58. * modules, showing both intrasegment and intersegment branching.  To show that it is
  59. * possible to mix-n-match, some references are made which use A5 and PC-relative
  60. * addressing. J. Kettenhofen, Cupertino, 10/15/90.
  61. * 
  62. *-------------------------------------------------------------------------------------------
  63.  
  64.     CASE    OBJ
  65.     INCLUDE    'intenv.a'        ; so we can get our args, open files, etc.
  66.     INCLUDE    'signal.a'        ; so we can handle 'Command-.'
  67.     INCLUDE 'TextUtils.a'    ; for NumToString
  68.     IMPORT    INITCURSORCTL    ; to init the spinning beach ball
  69.     IMPORT    ROTATECURSOR    ; for the spinning beach ball
  70.  
  71. RC_Normal    EQU    0
  72. RC_ParmErrs EQU    1
  73. RC_Abort    EQU    2         ; Return codes
  74.  
  75. ;SIGINT    EQU    2
  76.  
  77. EOLChar    EQU    $0D        ; the Return character marks the end of line
  78.     STRING    Pascal        ; length byte strings
  79.     
  80. BufSize    EQU    1024        ; size of input buffer
  81.  
  82. * global data--these declarations outside of any module are allocated and accessed
  83. * relative to register A5
  84. Globals    RECORD
  85. ArgV    DS.L    1        ; the address of our arguments
  86. ArgC    DS.L    1        ; the number of our arguments
  87. RetCode    DC.B    RC_Normal        ; set to RC_ …
  88. CRStr    DC.W    $010D        ; a 'string' that is a return character
  89. Interrupted    DC.B    0    ; not interrupted yet
  90. progname    DS.L    1    ; the address of our name
  91. NumFiles    DC.W    0    ; the number of files to process
  92. WriteChars    DC.B    0    ; TRUE if the user wants line count
  93. WriteLines    DC.B    0    ; TRUE if the user wants char count
  94. Opts        DC.B    0    ; TRUE if user has selected either line or char
  95. LineCount    DC.L    0
  96. CharCount    DC.L    0
  97. TotalLines    DC.L    0
  98. TotalChars    DC.L    0
  99. Max    DC.B    5            ; length of 'Total' string, or the longest filename
  100. myBuf    DS.B    BufSize    ; for reading from the file
  101. curByte    DC.W    -1        ; the current offset in myBuf
  102. lastByte    DS.W    1    ; last valid byte in myBuf
  103.     ENDR
  104.  
  105.  
  106. *******************************************************************
  107. *  ROUTINE        WriteStrings
  108. *  FUNCTION        calls write for an arbitrary number of strings
  109. *  INPUT        a NIL pointer on stack, followed by arbitrary number of string pointers,
  110. *        and the file descriptor
  111. *  OUTPUT        none
  112. *  NOTES        PROCEDURE    WriteStrings (NIL, Str^ …,FD);
  113. *******************************************************************
  114.         SEG 'Write'
  115. WriteStrings    PROC
  116.     Link    A6,#0        ; set up a stack frame
  117.     Move.L    A2,-(SP)    ; and save one permanent register
  118.     LEA        8(A6),A2    ; point A2 at first (last) parameter
  119.  
  120. * next, create a call block for the write routine on the stack
  121.     Clr.L    -(SP)        ; set the length to zero
  122.     SubQ    #8,SP        ; make room for the buffer and fd
  123.     Move.L    (A2)+,(SP)    ; put the file descriptor in its place
  124.  
  125. * now pull the arguments off the stack and write them out
  126. @1    Move.L    (A2)+,D0    ; get the string pointer
  127.     BEQ.S    @0            ; the list of strings is NIL terminated
  128.     Move.L    D0,A0        ; move the pointer so we can use it
  129.     Move.B    (A0)+,11(SP)    ; to move the length byte into the length arg
  130.     Move.L    A0,4(SP)    ; move the pointer into the buffer arg
  131.     JSR        (write).L    ; write it--CASE is significant
  132.     BRA.S    @1            ; and try again
  133.  
  134. *  done writing.  Clean up the stack and return
  135. @0    Move.L    A2,A1        ; we still need this
  136.     Move.L    -4(A6),A2    ; restore A2
  137.     UNLK    A6            ; throw away the scratch stack stuff
  138.     Move.L    (SP),A0        ; get the return address
  139.     Move.L    A1,SP        ; throw away the parameters
  140.     JMP        (A0)            ; and bail out
  141.     ENDPROC
  142.  
  143.  
  144. *******************************************************************
  145. *  ROUTINE        Stop
  146. *  FUNCTION        terminates execution
  147. *  INPUT        Message(A6)--error message to display on exit
  148. *  OUTPUT        Tool execution is terminated--return to MPW shell
  149. *  NOTES        call with a JMP, not a JSR--it doesn't return to caller anyway
  150. *******************************************************************
  151.     SEG 'STOP'
  152. Stop    PROC
  153.  
  154. *  don't bother to save permanent registers--we're never going back to the caller
  155.     WITH    Globals
  156.     MoveQ    #0,D0
  157.     Move.B    (RetCode).L,D0        ; we'll return this status
  158.     TST.B    Interrupted
  159.     BEQ.S    @1
  160.     Move.B    #RC_Abort,D0    ; unless we were interrupted
  161.  
  162. @1    Move.L    D0,-(SP)
  163.     JSR        (exit).L        ; (does not return)
  164.     ENDWITH
  165.     ENDPROC
  166.  
  167.  
  168. *******************************************************************
  169. *  ROUTINE        Intr
  170. *  FUNCTION        sets the global Interrupted to TRUE--passed to the Runtime routine
  171. *  INPUT
  172. *  OUTPUT        Interrupted is set TRUE
  173. *  NOTES
  174. *******************************************************************
  175.  
  176. Intr    PROC
  177.     ST    Globals.Interrupted
  178.     RTS
  179.     ENDPROC
  180.  
  181.  
  182. *******************************************************************
  183. *  ROUTINE        SyntaxError
  184. *  FUNCTION        Report a syntax error for the command line
  185. *  INPUT        above(A7)--pointers to strings to append to the error message
  186. *  OUTPUT        displays error message and calls Stop to terminate program execution
  187. *  NOTES        call with a JMP, not a JSR--it doesn't return anyway
  188. *******************************************************************
  189.  
  190. SyntaxError    PROC
  191.  
  192.     WITH    Globals
  193.     DC.W    $A9FF
  194.     PEA        #' - '
  195.     Move.L    (progName).L,-(SP)
  196.     PEA        #'### '
  197.     PEA        DiagnosticFD
  198.     JSR        (WriteStrings).L        ; finish writing the error line
  199.     CLR.L    -(SP)
  200.     PEA        CrStr
  201.     PEA        #' [-l] [-c] [files…].'
  202.     Move.L    progName,-(SP)
  203.     PEA        #'# Usage - '
  204.     PEA        (DiagnosticFD).L
  205.     JSR        (WriteStrings).L        ; and write the 'usage' line
  206.     JMP        (Stop).L
  207.     ENDWITH
  208.     ENDPROC
  209.  
  210.  
  211.  
  212. *******************************************************************
  213. *  ROUTINE        LetterOpt
  214. *  FUNCTION        Set a letter    option
  215. *  INPUT        D0--char
  216. *        D4--ArgVIndex
  217. *        A1--address of current option
  218. *  OUTPUT        if char = valid option, set option flag, else syntaxerror
  219. *  NOTES        PROCEDURE    LetterOpt(Opt: Char; VAR ArgVIndex: Integer);
  220. *        ArgVIndex can be updated by this routine to skip arguments to options
  221. *******************************************************************
  222.  
  223. LetterOpt    PROC
  224.     Cmp.B    #'l',D0
  225.     BEQ.S    @0
  226.     Cmp.B    #'L',D0                    ; -l?
  227.     BNE.S    @1
  228. @0    ST        (Globals.WriteLines).L    ; means only lines
  229.     ADDQ.B    #1,Globals.Opts            ; yes, an option has been selected
  230.     RTS
  231. @1    Cmp.B    #'c',D0                    ; -c?
  232.     BEQ.S    @2
  233.     Cmp.B    #'C',D0
  234.     BNE.S    @3
  235. @2    ST        Globals.WriteChars    ; means only characters
  236.     ADDQ.B    #1,Globals.Opts        ; yes, an option has been selected
  237.     RTS
  238. @3    Clr.L    -(SP)            ; otherwise it's a bad option
  239.     PEA        Globals.CRStr
  240.     PEA        #'" is not an option.'
  241.     Move.L    A1,-(SP)        ; pointer to current option
  242.     PEA        #'"'            ; the leading quote around the option
  243.     JMP        SyntaxError
  244. *  SyntaxError never returns
  245.     ENDPROC
  246.  
  247.  
  248. *******************************************************************
  249. *  ROUTINE        Init
  250. *  FUNCTION        Tool initalization
  251. *  INPUT
  252. *  OUTPUT
  253. *  NOTES        PROCEDURE Init;
  254. *******************************************************************
  255.     SEG 'INIT'
  256. Init    PROC
  257.  
  258. ForPascal    EQU    1        ; Make envp & argv strings "Pascal" format
  259.                         ; (preceded with a length byte)
  260.  
  261. ; Comments about the Init.SF structure
  262. ; 1. TEMPLATE. Note that this is a template, not a record;
  263. ; it is equivalent to a 'struct' in C or a type
  264. ; definition in Pascal.  It does not allocate space.
  265. ; 2. DECREMENT. It is used to describe a "stack frame".  Since
  266. ; the stack grows downward, the keyword 'Decrement' is used.
  267. ; 3. The bracketed parameter, '{OldA6}'. This tells the Assembler to
  268. ; calculate field offsets using this field as the '0' offset.
  269. ; This is explained more fully in the MPW Assembler Manual.
  270. ; 4. SIZE field. The size field here is the calculated as the 
  271. ; difference from 0...this turns out to be -4, which
  272. ; turns out to be the amount of space that we have to
  273. ; allocate on the stack via a Link instruction for our
  274. ; local parameters.
  275. ; If we were to have incoming parameters, then we
  276. ; could allocate them above the OldA6 field; what
  277. ; order the parameters are found, and their relation
  278. ; to the routine Return Address varies between C and
  279. ; Pascal; appendices in the MPW language manuals contain
  280. ; more details about language calling conventions.
  281.  
  282. InitSF    RECORD    {OldA6},DECREMENT
  283. ShellRet    DS.L    1        ;'RetPC' in Ch. 12 of MPW Manual
  284. RetAddress    DS.L    1        
  285. OldA6        DS.L    1
  286. EnvP        DS.L    1
  287. Size        EQU    *
  288.     ENDR
  289.  
  290.     WITH    Globals
  291.     Link    A6,#InitSF.Size
  292.     PEA        ForPascal            ; optimized Move.L #1,-(SP)
  293.     PEA        InitSF.EnvP(A6)        ; for Shell Exported variables
  294.     PEA        ArgV                ; Address to store ptr to Command Line Arguments
  295.     PEA        ArgC                ; Address to store ptr to # of Cmd Line Args.
  296.     Move.L    InitSF.ShellRet(A6),-(SP)
  297.     JSR        (_RTInit).L            ; get things set up
  298.     LEA        InitSF.Size(A6),SP    ; throw away the arguments
  299.     PEA        Intr                ; our interrupt handler
  300.     Move.L    #SIGINT,-(SP)
  301.     JSR        (signal).L        ; so we can handle user interrupts
  302. * D0 has handle to prevSig, which we will ignore
  303.     LEA        InitSF.Size(A6),SP    ; throw away the arguments
  304.  
  305.     MoveM.L    A2/D3-D4,-(SP)    ; let's do some ArgV processing
  306.     Move.L    ArgV,A2
  307.     Move.L    ArgC,D3
  308.     Move.L    (A2)+,progName    ; we now have a global that points to our name
  309.     Move.B    #RC_ParmErrs,(RetCode).L
  310.     MoveQ    #0,D4            ; ArgVIndex := 0;
  311. @0    AddQ    #1,D4
  312.     Cmp.L    D4,D3
  313.     BLE.S    DoneArgOptions
  314.     Move.L    (A2)+,A0        ; get the next arg
  315.     Move.L    A0,A1            ; keep a pointer to the start of the string
  316.     Move.B    (A0)+,D1        ; get the len
  317.     BEQ.S    @0                ; arg := ''; get the next one
  318.     Move.B    (A0)+,D0
  319.     Cmp.B    #'-',D0            ; is it an option?
  320.     BNE.S    @1
  321.     Move.B    (A0)+,D0
  322.     JSR        (LetterOpt).L
  323. * caller to LetterOpt can check if ArgIndex changed--if so, skip the increment of ArgIndex
  324.     BRA.S    @0        ; go again
  325. @1    AddQ    #1,NumFiles        ; bump the file count
  326.     Cmp.B    Max,D1            ; a new longest name?
  327.     BLE.S    @0
  328.     Move.B    D1,Max            ; a new max
  329.     BRA.S    @0
  330.  
  331. DoneArgOptions
  332.     Move.B    #RC_Normal,RetCode        ; parameters ok so far
  333.     Clr.L    -(SP)
  334.     JSR        (InitCursorCtl).L        ; initialize the spinning cursor
  335.     Tst.B    Interrupted                ; user break yet?
  336.     BEQ.S    @3
  337.     JMP        Stop
  338. @3    MoveM.L    (SP)+,A2/D3-D4
  339.     UNLK    A6
  340.     RTS
  341.     ENDWITH
  342.     ENDPROC
  343.  
  344. *******************************************************************
  345. *  ROUTINE        PrintCount
  346. *  FUNCTION        writes the filename (if needed), linecount and/or charcount to standard output
  347. *  INPUT        pointer to the filename in A2 (if counting multiple files)
  348. *  OUTPUT
  349. *  NOTES
  350. *******************************************************************
  351.  
  352. PrintCount    PROC
  353. PrintSF        RECORD    0,DECREMENT
  354. LineBuf        DS.B    256
  355. tempStr        DS.B    10
  356. MaxBlanks    DS.B    1
  357.         ALIGN
  358. Size        EQU        *
  359.     ENDR
  360.  
  361.     LINK    A6,#PrintSF.Size
  362.     MoveM.L    D6/A3,-(SP)
  363.  
  364.     Move.W    #(256/4)-1,D0            ; fill LineBuf with blanks
  365.     Move.L    #'    ',D1
  366.     LEA        PrintSF.LineBuf(A6),A0
  367. @0    Move.L    D1,(A0)+
  368.     DBRA    D0,@0
  369.  
  370.     WITH    Globals
  371.     MoveQ    #3,D6            ; skip first three blanks
  372.     LEA        4+PrintSF.LineBuf(A6),A3    ; A3 is the current offset into lineBuf
  373.     Cmp.W    #1,NumFiles        ; >1 if more than one file
  374.     BLE.S    noName
  375.  
  376.     Move.L    D7,A0            ; D7 points to the current filename
  377.     MoveQ    #0,D1
  378.     Move.B    (A0)+,D1        ; get the length byte
  379.     Add.B    D1,D6            ; update the new length
  380.     MoveQ    #0,D0
  381.     Move.B    Max,D0            ; Max is the longest name
  382.     Sub.B    D1,D0            ; D0 is how much shorter current is than max
  383.     AddQ    #3,D0
  384.     Add.B    D0,D6            ; update the counter
  385.     BRA.S    @2                ; zero base the length
  386. @1    Move.B    (A0)+,(A3)+
  387. @2    DBRA    D1,@1            ; move in the filename
  388.     Add.W    D0,A3            ; and update our roving pointer
  389.  
  390. noName
  391.     ENTRY    DoLines,DoChars,WriteBuf
  392.     ; if no options selected, print both lines and chars.
  393.     TST.B    Opts
  394.     BNE.S    @0
  395.      
  396.      JSR    DoLines            ; insert lines into buffer
  397.      JSR    DoChars            ; insert chars into buffer
  398.      BRA.S    @Exit
  399.  
  400. @0    TST.B    WriteLines        ; do we want to print the line count?
  401.     BEQ.S    @1
  402.      JSR    DoLines            ; insert lines into buffer
  403. @1    TST.B    WriteChars
  404.     BEQ.S    @Exit
  405.      JSR    DoChars            ; insert chars into buffer
  406.  
  407. @Exit    
  408.     Move.B    D6,PrintSF.lineBuf(A6)    ; set the length byte
  409.  
  410.     CLR.L    -(SP)            ; set up the stack for WriteStrings
  411.     PEA        CRStr
  412.     PEA        PrintSF.linebuf(A6)
  413.     PEA        OutputFD
  414.     JSR        WriteStrings
  415.     MoveM.L    (SP)+,D6/A3
  416.     UNLK    A6
  417.     RTS
  418.  
  419.         
  420. DoLines         
  421.     Move.L    lineCount,D0
  422.     add.w    #10,D6            ; update counter
  423.     JMP        WriteBuf
  424.     
  425. DoChars
  426.     MOVE.L    charcount,D0
  427.     add.w    #13,D6            ; add field length and 3 blanks to counter
  428.     JMP        WriteBuf
  429.  
  430. WriteBuf    
  431.     LEA    PrintSF.tempStr(A6),A0
  432.     _NumToString
  433.  
  434.     MoveQ    #0,D1
  435.     Move.B    (A0)+,D1
  436.     MoveQ    #10,D0        ; we'll say this field is 10 long
  437.     Sub.B    D1,D0        ; D0 := field length-length of numstring
  438.     Add.W    D0,A3        ; skip the extra padding
  439.  
  440.     BRA.S    @2            ; zero base by doing the DBCC first
  441. @1    Move.B    (A0)+,(A3)+
  442. @2    DBRA    D1,@1        ; move in the number
  443.     RTS
  444.     ENDWITH
  445.     ENDPROC
  446.  
  447.  
  448. *******************************************************************
  449. *  ROUTINE        PrintTotals
  450. *  FUNCTION        writes the summary line to standard output
  451. *  INPUT
  452. *  OUTPUT
  453. *  NOTES        calls PrintCount to print the totals if appropriate
  454. *******************************************************************
  455.     SEG 'PrintTotals'
  456. PrintTotals    PROC
  457.     Cmp.W    #1,Globals.numFiles
  458.     BGT.S    @0
  459.     RTS            ; do nothing if only one file
  460. @0    LEA        #'Total',A0
  461.     Move.L    A0,D7        ; our new 'filename'
  462.     Move.L    Globals.totallines,Globals.linecount
  463.     Move.L    Globals.totalchars,Globals.charcount
  464.     JSR        (PrintCount).L        ; recycled code
  465.     RTS
  466.  
  467.     ENDPROC
  468.  
  469.  
  470. *******************************************************************
  471. *  ROUTINE        GetChar
  472. *  FUNCTION        reads from the file in hunks, and hands out a character at a time
  473. *  INPUT        fd:  long in D4--the file descriptor for the file to read
  474. *  OUTPUT        the next character in D0--zero = TRUE means end of file
  475. *  NOTES
  476. *******************************************************************
  477.     SEG 'GetChar'
  478. GetChar    PROC
  479.     WITH    Globals
  480.     Move.W    curByte,D1    ; get the current offset
  481.     BPL.S    @0            ; we have a valid block currently
  482. @1    PEA        BufSize        ; Move.L #BufSize,-(SP)--count
  483.     PEA        mybuf        ; where
  484.     Move.L    D4,-(SP)    ; the file descriptor
  485.     JSR        (read).L    ; read the next block
  486.     LEA    12(SP),SP        ; clean up the stack
  487.     MoveQ    #0,D1        ; start at the beginning again
  488.     Move.W    D0,lastByte
  489.     BNE.S    @2            ; end of file?
  490.     RTS                    ; pass the zero flag back to the caller
  491. @0    Move.W    lastByte,D0    ; get the last valid byte
  492. @2    Cmp.W    D0,D1
  493.     BGE.S    @1
  494.     LEA        mybuf,A0
  495.     Move.B    0(A0,D1),D0    ; read the next character
  496.     AddQ.W    #1,D1
  497.     Move.W    D1,curByte    ; update curByte
  498.     RTS
  499.     ENDWITH
  500.     ENDPROC
  501.  
  502.  
  503. *******************************************************************
  504. *  ROUTINE        CountFile (fd:filedescriptor)
  505. *  FUNCTION        counts the lines and characters in fd
  506. *  INPUT        fd:  long--the file descriptor for the file to count
  507. *  OUTPUT        charcount, linecount, totalchars, totallines updated
  508. *  NOTES
  509. *******************************************************************
  510.     SEG 'CountFile'
  511. CountFile    PROC
  512.     WITH    globals
  513.     CLR.L    linecount
  514.     Move.L    (SP)+,A1    ; save the return address
  515.     Move.L    (SP),D0        ; and the file descriptor
  516.     Move.L    A1,(SP)        ; return the return address
  517.  
  518.     MoveM.L    D4-D7,-(SP)
  519.     Move.L    D0,D4        ; save the fd for the getchar routine
  520.     MoveQ    #0,D7        ; initialize our counter registers
  521.     MoveQ    #0,D6
  522.  
  523. ReadLoop    
  524.     JSR        getchar
  525.     BEQ.S    fileEnd        ; zero means no more bytes to read
  526.     AddQ.L    #1,D7        ; otherwise bump the char counter
  527.     Move.B    D0,D5        ; save the char in a permanent register
  528.     CMP.B    #EOLChar,D5    ; bump linecount?
  529.     BNE.S    ReadLoop
  530.  
  531.     AddQ.L    #1,D6        ; yes
  532.     Move.L    D6,-(SP)
  533.     JSR        (RotateCursor).L    ; spin the ball
  534.     Tst.B    Interrupted        ; user break yet?
  535.     BEQ.S    ReadLoop        ; no--continue
  536.     JMP        (Stop).L        ; abort mission
  537.  
  538. fileEnd    
  539.     CMP.B    #EOLChar,D5    ; was the last character read a line end?
  540.     BEQ.S    @0
  541.     TST.L    D7        ; have we counted any characters
  542.     BEQ.S    @0        ; no--don't increment line count
  543.     AddQ.L    #1,D6
  544. @0    Move.L    D6,lineCount        ; update globals and leave
  545.     Move.L    D7,charCount
  546.     Add.L    D6,totallines
  547.     Add.L    D7,totalchars
  548.     MoveM.L    (SP)+,D4-D7
  549.     RTS
  550.     ENDPROC
  551.  
  552.  
  553. *******************************************************************
  554. *  ROUTINE        Count
  555. *  FUNCTION        the MAIN proc--calls Init, then processes the files
  556. *  INPUT
  557. *  OUTPUT
  558. *  NOTES
  559. *******************************************************************
  560.  
  561.     SEG 'MAIN'
  562. Count    MAIN
  563.     IMPORT    c2pstr,p2cstr
  564.     WITH    Globals
  565.     JSR        (Init).L
  566.     Move.L    ArgV,A2
  567.     ADDQ    #4,A2        ; skip the program name
  568.     Move.L    (A2)+,D7    ; set the cc's
  569.     BNE.S    @0            ; otherwise count stdin
  570.  
  571. * CountStdIn
  572.     Clr.L    -(SP)        ; we don't need to open standard input
  573.     JSR        (CountFile).L
  574.     JSR        (PrintCount).L
  575.     JMP        (Stop).L
  576.  
  577. @1    Move.L    (A2)+,D7    ; set the cc's
  578.     BEQ.S    ShowTotals    ; ArgV is NIL terminated
  579.  
  580. @0    Move.L    D7,A0
  581.     Move.B    (A0)+,D0    ; pick up the length byte
  582.     BEQ.S    @1            ; zero length--next, please
  583.     Move.B    (A0)+,D1    ; now the first charcter
  584.     Cmp.B    #'-',D1        ; an option--already handled by Init
  585.     BEQ.S    @1
  586.  
  587. * otherwise we have a file to process
  588.     Move.L    D7,-(SP)        ; convert the filename to a C string
  589.     JSR        (p2cstr).L
  590.     PEA        O_RDONLY
  591.     Move.L    D7,-(SP)
  592.     JSR        (open).L        ; open the file
  593.     Move.L    D0,D6            ; save the result--fd or error
  594.     JSR        (c2pstr).L        ; love those length bytes
  595.     LEA        12(SP),SP        ; throw away the arguments
  596.     Move.L    D6,-(SP)        ; push the fd
  597.     BMI.S    BailOut            ;  an error if negative
  598.     JSR        (CountFile).L
  599.     JSR        (PrintCount).L
  600.     BRA.S    @1
  601.  
  602. ShowTotals
  603.     JSR        (PrintTotals).L
  604.     JMP        (Stop).L
  605.  
  606. BailOut    CLR.L    (SP)        ; space came from move D6 above
  607.     PEA        CRStr
  608.     Move.L    D7,-(SP)
  609.     PEA        #' - could not open file '
  610.     Move.L    progName,-(SP)
  611.     PEA        #'### '
  612.     PEA        DiagnosticFD    ; optimized Move.L #DiagnosticFD,-(SP)
  613.     JSR        (WriteStrings).L
  614.  
  615.     CLR.L    -(SP)
  616.     PEA        CRStr
  617.     PEA        #' [-l] [-c] [files…].'
  618.     Move.L    progName,-(SP)
  619.     PEA        #'# Usage - '
  620.     PEA        DiagnosticFD    ; optimized Move.L #DiagnosticFD,-(SP)
  621.     JSR        (WriteStrings).L
  622.     Move.B    #RC_ParmErrs,RetCode
  623.     JMP        (Stop).L
  624.  
  625.     ENDWITH
  626.     ENDPROC
  627.  
  628.     END
  629.  
  630.